"""
@-*- coding: utf-8 -*-
@ python：python 3.8
@ 创建人员:ylx-lingxiao
@ 创建时间:2024/10/8  22:09
@ File:study2.py.py
@ Explanation:
"""
"""
数字类型:int整型  float浮点型
工厂函数:int()  float() 可以做格式转换将其转换为整型或者浮点型
Python中的注释掉本行是给前面加#，多行批量注释，Ctrl /，给这行的后面加#，可以在这个后面写注释，当前行中，#后的不会执行
a = 5
b = float(a)
print(b)
输出 5.0 
浮点转为整型 只保留整数位 5.3转为5  5.8转为5  -5.8转为-5
0.5转换成0


布尔类型 True False,一般用于判断事情的真假
print(3>2)   True
print(3>5)   False
print(3==5)   False
如果参与数学运算，则True = 1  False = 0
print(1+True)  2
print(1+False) 1


字符类型
工厂函数 str() 直接将其他类型转为字符串类型，值加引号就行
英文单引号 ''
英文双引号""
英文三单引号  单引号按钮按三下
英文三双引号  双引号按钮按三下
这样来解决了一个问题，如果字符串中有引号怎么办，字符串的识别规则是找到一对匹配的引号，就把它识别成一个整体，若字符串本身就有单引号或者双引号，那我们最
外侧就要使用三单引号或者三双引号，字符串的原则就是最外层的匹配到一起即可。

操作
切片-单切,0代表第一个字符，正着是从0开始，倒着是从-1开始
a = '大家好，我是渣渣辉，是兄弟就来k我8'
aa = a[0] 输出 大
aaa = a[5] 输出 是
b = a[-1] 输出 8
bb = b[-6] 输出 弟

切片-多切,左闭右开，前面不写，默认从头开始取，后面不写，默认一直取到尾，前后都不写，那就是都取
aa = a[0:3] 输出 大家好  取0 1 2 
aaa = a[6:9] 输出 渣渣辉 取6 7 8

切片扩展-翻转字符串
aa = [::-1] 输出 反着 每个都取
aa = [::1] 输出 全取
aa = [::2] 输出  正向 空1个一取
aa = [::3} 输出 正向 空2个一取
aa = [::-3] 输出 反着，空2个一取

我们是从a中切片获取值，然后赋值给了其他变量，但是a本身不受切片的影响，没有变化；切片本身不会影响原来的字符串，原字符串不会被损坏

格式化,既针对某种字符串，我们可以处理成特定的形式，将其格式化或者模板化
方式1 字符串 %s int %d float %f
name = '渣渣辉'
number = 8
a = '大家好，我是%s，是兄弟就来k我%d刀'%(name,number)  如果仅有1个变量，则直接后面写%s,如果是2个及以上则需要%(),括号内变量名用逗号隔开
print的结果会随着name和number的变化，输出的值也会变化
这种写法，就是逐个对应的关系，第一个变量的值，换前面的第一个，如果number 和 name 替换那么执行就会报错，因为不匹配 %s 对应的是字符串类型
%s 可以做兼容处理所有的类型，所以可以里边都用%s,比如number= 888.88 后面的%d 使用%s 替换，执行不会报错，会处理为888.88刀，只不过这个是'888.88'
%d 可以兼容处理 int 和 float型，比如说上面把number 给成888.88，输出的时候 会成为888
%f 默认保留6位小数，不够就补0，比如你给整数8 就会转换为8.000000，我们使用%.3f,代表小数点后留3位，此处会四舍五入，%.0f,小数点后不要了，四舍五入

方式2 f'{}',只需要将变量名放进括号内即可，f在整个字符串的最外层
a = f'大家好，我是{name}，是兄弟就来k我{number}刀'
a = f'大家好，我是{name}，是兄弟就%s来k我{number}刀'%'快'   这种也可以，可以混合使用，避免语句中本身就有花括号导致的冲突

转义
\t 指制表符，代表4个空格，既一个tab,此处可用于后续的一个乘法口诀表的作业，制表符，使得大家的距离都一致
\n 换行符，代表字符串输出的时候，见到这个会换行
不想让\有这个转义的特殊含义，可以使用\\来取消转义，运行出来如\\n 最后打印出来就是\n

原始字符串-让所有的转义符瞬间失效，直接给字符串前面加个r'',字符串里边的转义全部失效

字符串的常用操作
1.拼接 + 
2.重复 *  后面跟数字可以代表重复出现多少次
a = '我是'
b = 'lol'
c = a + b  拼接到一起 输出 '我是lol'
c = a + b*3 拼接到一起 输出'我是lollollol'  运算法则-先乘除后加减，先算括号内的再算括号外的-目前这种仅适用于字符串
3.字符串以什么开头 startswith 返回的结果是True 或False  必须连续匹配即可，若字符中有空格，那也是字符串的一部分
4.字符串以什么结尾 endswith 返回的结果是True 或False
aa = 'hello everyone my name is lx'
print(aa.startswith('hello')) 返回的True
print(aa.endswith('lx')) 返回的True
5.去除开头和结尾的空格及换行符 strip，只管开头和结尾，中间不管
aa = '   my name is lx  \n'   拿鼠标去点原本的输出，结尾会有光标，证明尾巴上本身有空格
print(aa.strip()) 去除前后空格，和换行符
6.查找 find  看我要找的字符串在目标字符串中是否存在，如果有，返回这个字符串的第一个字符，在目标字符串的起始位置-下标索引的这个数字,开始的位置，如果
没有找到，则返回-1，如果找到，最小是从0开始，后续可以直接判断返回值大于等于0，那就证明一定找到了，如果你只关心是不是有，是不是包含就可以这样

如果里边有多个，只返回最先找到的那个，最前面的那个，匹配的第一个的下标
aa = 'hello everyone my name is lx'
aa.find('eve') 

7.替换 replace 用于替换这个字符串中的某个片段-----这个操作不会改变原有字符串，而是生成了一个新的值
aa = 'hello everyone my name is lx'
aa.replace('你想改的','你想改成什么')
aa.replace('lx','ylx')
如果里边有多个相同的目标值，则会全部替换为你想要改的值，只能替换一个值，不能既替换这个又替换那个

8.纯字母  判断字符串是不是由纯字母(大小写均可)构成-isalpha,是的话，返回True,否则返回False,字符串含有字母+空格 也不行，返回False，比如 'hello world'
9.纯数字  isdigit  是的话，返回True,否则返回False   形如aa.isdigit()

10.计数 count 统计字符串中某个字符串出现的次数，区分字母的大小写
aa = 'adsdasdasdasdsad'
print(a.count('a'))  统计在字符串aa中 a出现的次数

pycharm中 Ctrl F 是搜索功能
type() 是Python中输出数据类型的工厂函数


列表和元组
列表和元组的区别是什么？ 列表是可变对象，元组是不可变对象，可变的指的是对一个列表的元素可以进行增删改---元组真的不可以修改吗？不是，元组本身虽然不能修改
如果元组中含有列表，我可以先切片获取列表，此时再对列表中的子元素进行修改，可以修改这个列表中的子元素
列表 list  []
元组  tuple ()
1.当其中只有一个元素时
列表可以正常放，如[1] 但是元组不可以，必须给这个元素的尾巴加一个逗号(1,)
如果你写成(1),那么你打印的结果将是1  int类型的数据  ('hhh') 输出 'hhh' str类型
对于小括号来说，如果只是单纯的小括号里放了一个数据，那么你放的是什么类型的数据，就会输出什么类型的数据

2.共性：都能存放任意数量 任意类型的 Python对象，里边什么数据类型都可以放，可以放无数个;都是内部有序的，内部顺序固定，所以也支持切片，单切和组合切均可以
切的是里边每个元素对应的下标，而元组和列表中每个元素用逗号隔开，下标从0开始
对于这种切片，我们还可以根据切片所得到的元素进行二次切片，如果支持的话(既你前面切片得到的对象必须支持切片)，比如说你第一次切片得到的是一个字符串

3.列表和元组最大的区别在于列表可以增删改，元组不可以，简单来说，列表是Python中的可变对象，元组是不可变对象，列表指的是我可以给列表中增加 删除  修改元素
但是元组不支持，一个元组只要形成，那就是买定离手
aa = [1,2,3,4,5]

以下这些操作，元组执行就会报错，是列表的方法，且这些操作，影响的是列表的本身，所以列表是一个可变的对象，但是元组不可以

追加-append  列表的尾部添加
aa.append(5) 输出结果打印aa 则展示 [1,2,3,4,5,5]


插入-insert  指定的下标索引的位置去插入
aa.insert(0,5) 输出结果打印aa 则展示 [5,1,2,3,4,5,5]    起始位置插入，这个位置本身的元素向后移动

删除-del  按照下标索引删除
del aa[0]  
print(aa)  打印输出 [1,2,3,4,5,5]

删除-remove 按照给的值来删除，且一次只能删除一个，先找到的先删除，从前往后
aa.remove(5)  输出结果打印aa 则展示 [1,2,3,4,5]

修改-下标然后重新赋值即可，给指定的某个下标位置重新赋值
aa[2] = 888
print(aa)  输出结果打印aa 则展示 [1,2,888,4,5]


公共方法 count(),元组和列表都可以
aa.count(5)


以下2个方法不是列表或元组的属性，是字符串的
合并 join  处理一个纯字符串构成的列表，将列表中的元素合并成一个大字符串
aa =['lx','js']
bb = '-'.join(aa) 输出 lx-js   列表中的每一个元素，用前面的字符串给链接起来
aa 本身没有改变

拆分 split
aa = 'lx-js'
bb = aa.split('-')  用哪个字符串片段去拆，拆的东西就不要了     aa本身没有改变
输出一个列表  ['lx','js']

a = 'lijian-daofeng-manba'
print(a.split("a"))   a最后一个也有，和引号之间为空，所以刚好成为一个空字符串
输出['liji','n-d','ofeng-m','nb','']
split() 默认就是用空格来拆分
没有拆的话会把整个字符串放在列表中，整体就是一个列表，因为无法拆，列表中就1个元素


集合
工厂函数-set()，将某个其他类型的值转化为集合类型
形如{key1,key2,key3}
e = {1,2,3,4,5}
e.add(6)  输出{1,2,3,4,5,6}
集合最大的特征
1.里边可以放任意类型，任意数量的Python对象
2.去重，不允许有重复的元素出现，有的话只保留一个
3.无序，不能通过下标索引去切片，集合是无序的，输出不保证顺序，不管前后，集合是无序的，你即使看到的顺序也不是真正的顺序，虽然输出的时候你看到了排序
但是取的时候也没有固定的顺序，没有顺序的概念，也不让你按照这个去取值
我们看到的是，它去重了，重复的只留了一个，然后保留的元素表面看起来排了个顺序，然后去输出以下即可

Python的去重方法：
如果你想对一个列表去重，那你可以把这个列表先转化为集合然后再转为列表，就可以完成去重
先set() 再list()
去重后再转化为列表，列表的顺序会发生变化

工厂函数并没有改变对象本身，所以转化得到的值需要用变量去接

a-b   仅a特有
b-a   仅b特有
a|b   全集，把2个放在一起按照集合去重的逻辑把相同的去掉
a&b   交集
a^b   仅a特有+仅b特有


字典dict() key不能重复，值可以重复
成对去存放，key value 的键值对的形式，成对出现，一组完了后使用逗号隔开
a = {'name':'jenny','age':18}
print(a,type(a))
字典的键，要求不可以重复，相同的key只能有一个，给的重复了，会用后面的来覆盖前面的
什么可以做key--int float bool 布尔类型 字符串 元组（元组内不能包含列表集合字典，既纯元组），也就是说列表，集合，字典本身是不能做key的
值没有要求，什么都可以
一定可以做key的   int float bool str 
一定不可以做key的 list set dict
看情况，纯元组，既只包含 int float bool str 类型的值的元组tuple可以做key，含有set dict list的元组不能做key

a = {} 这种类型是空字典，不是空集合

字典
新增，是一个动作，对本身，无返回值
a['name'] = 'manba'
修改，是一个动作，对本身，无返回值
a['name'] = 'lxy'  给这个key重新赋值，后面的会覆盖前面的

删除
del  a['name'] 按key删除，对应的键值对   是一个操作，删除的是a本身，没有返回值
pop 是一个动作，但是其特殊性就在于它有返回值 a.pop('name')  会删除对应的键值对，并且返回键对应的值，既你要删除的这个键值对的值，所以可以用变量来接，这也就是pop删除的特殊之处
虽然是一个动作，但是有返回值
clear  a.clear()   动作，没有返回值，直接对a本身操作，a变为空字典{}

a = {'name':'曼巴','age':18}
字典的特殊属性，这三个返回的是一种特殊的类型，这种不是常规类型，我们可以使用这个方法，然后再使用我们常规数据类型的工厂函数做转化即可取值
a.keys() 所有的键放在一起 dict_keys(['name','age'])
a.values() 所有的值放在一起dict_keys(['曼巴','18'])
a.items() 每个键值对以元组的形式放在了一起 dict_items([('name','刀锋'),('age',18)])

字典没有索引概念，其对外界声明，是内部无序的
集合和字典都是无序的，无序的特征就是不能切片，没有索引




可变类型：列表 字典  集合   可变指的是ID不变，值可以变
不可变类型： 元组 字符串 数字类型如int float 布尔类型     
可变，从表面来看，代表我们可以增删改里边的值，对齐本身进行操作
不可变，指你确定后那就不能变
原理来说：
对象三要素 id() type() 值，这个ID是空间内存地址，这个ID仅仅保证在你的代码运行期间，同一个对象，它是唯一的ID
变量本身没有任何实质内容，变量本身取决于你给他的赋值，换句话来说就是变量引用了Python的对象
一个对象可以被多个变量同时引用
一个变量同时只能引用一个对象


常见的操作符
+
-
*
/   除完一定返回的是一个浮点型的值

取余，取两数相除的余数   %    5%3      2
                         10%3    1
                         1%3     1
                    
地板除 //  向下取整
乘方 ** 2**2   2**5  2的平方   2的5次方

累加 +=       
a = 5 
a += 2
print(a)   输出7    给a在原来的基础上+2，得到值再赋值给a


累乘 *=


比较运输符，返回的值是布尔类型  True False
>
>=  大于或等于
<
<=  小于或等于
==
!=
字符串比较大小，采用的是字典序-从小到大的顺序  0-9 A-Z a-z  越早出现的越小，越先出现的越小；字符串第一个开始比，第一个一样比第二个，分出胜负后面的就不比了
print('a0' > 'a')  输出 True

逻辑运算符    运算优先级  not> and > or 
not  结果取相反
and  同时为True 才能是True
or   有一个为True 最终结果为True
有括号的先算括号里边的


常用的Python的内置函数：
len() 获取一个Python对象的长度，数字类型没有len(),布尔类型没有len()，其余的常见的数据类型都可以用len(),字符串 元组 集合  字典 列表
字符串的长度，元素的个数
元组，值的个数
字典，键值对的个数
列表 元素的个数
集合 去重后元素的个数

range() 范围  里边的数字是左闭右开的
for n in range(1,10):
    print(n)
依次输出 1，2，3，4，5，6，7，8，9
再比如我们list(range(1,9)) 输出列表[1,2,3,4,5,6,7,8]   你可以转化我的类型，但是我本身就是range类型
你想循环几次，你就给这个range里一个几，默认从0开始
range(10),默认从0开始，取0 1 2 3 4 5 6 7 8 9

aa = range(0,10,2)
for n in aa:
    print(aa)        
取0 1 2 3 4 5 6 7 8 9 步长是2，一般不输入默认是1，也就是隔一个取一个     输出0 2 4 6 8


break()
可以终止单个的while循环也可以终止for循环

continue() 跳过，跳过当前这次的循环，本次循环后的代码也不走了，开始下次的循环
n%3 就是对3取余数，如果没有余数那么就是3的倍数
for n in range(1,10):
    if n%3 == 0:
        continue
    print(n)
输出 1 2 4 5 7 8


空语句 pass()  符合条件时，什么都不做，满足语法上的要求
for n in range(1,10):
    if n%3 == 0:
        continue
    print(n)
    if n%2 == 0:
        pass
    else:
        print(f'{n}我是奇数')
        
输出
1
1是奇数
2
4
5
5是奇数
7
7是奇数
8

绝对值abs
for n in range(-10,10):
    print(abs(n))

取商和余数 divmod()    以元组的形式(商，余数)
for n in range(1,10)
    print(divmod(n,3))


四舍五入
round(num,n) n表示保留几位小数，四舍五入   

互换
a = 3 
b = 'bcbx'
print(a)
print(b)
a,b = b,a
print(a)
print(b)
Python对象互换变量

工厂函数
int str float list tuple set dict

条件表达式
x = 5
y = 3

if x > y :
    smaller = y
else:
    smaller = x 
    
    
    
smaller = y if x>y else x


list_add = []
for n in range(1,11)
    if n%2 == 0:
        pass
    else:
        list_add.append(n)
        
        
list_add = [n for n in range(1,11) if n%2 == 1]
    

tab键默认就是四个空格
列表中的insert插入，若下标是-1，那么就插入的位置是最后一个，最后一个位置原有的数往后走，所以看起来像是插入到了倒数第二个位置，例如：
a = [1,2,3,4]
a.insert(-1,5)
print(a) 输出[1,2,3,5,4]

什么样的字符串能够转化为整数：纯数字构成的，如果前面有0或者无数个0，则会忽略0，形如'0000252'转化后会得到252，如果前面有-，如'-0000252'会转化为-252
                        形如'+000258'输出为258，所以要转化的时候有+-，必须出现在正常数字的最前方
什么样的字符串能够转化为小数：首先，int可以的，float一定可以
                        小数点位置任意最前，中间，后面，仅能有一个小数点，+-必须出现在最开头之前
                        形如'.4'  '4.'  分别按0.4  4.0处理   '-.4' 按-0.4处理
                                             
变量的类型是由赋值决定的
a = [0,1,2]
b = a.append(6)
print(b,type(b))  输出none
原因，append仅仅是一个动作，对a本身做出了改变，没有返回值，所以不要变量来接，append没有生成新的东西，只是把a进行了变动，如果操作后返回一个值，那么用变量
去接，才能有值，由数据类型；也就是说有返回你才能拿来赋值，没有返回，赋值无从说起

del 删除可以单切，可以多切，不过多切的时候是左闭右开
del a[1]
del a[:] 删除a全部的元素，或者右侧的值给大一点，超过a内所有的元素就可以
删除列表中的所有元素可以 a.clear()

a = [1,2,3,4,5]
print(a[1:9999])  输出[1,2,3,4,5]
print(a[:]) 输出[1,2,3,4,5]类似这样其实冒号前后给的就是负无穷大到正无穷大
也就是说如果你要切片，左右的值可以夸张，但是一定要包含到当前的这个范围中才能全部取到
像这种仅能组和切片，单切不允许给超出范围的值，类似横轴的取值，组合切相当于一个范围，你只要能覆盖这个区间段的值就可以了，单切的话超过范围就不行了

a = [0,1,2,3,4,5,6,7,8,9]
print(a[-5:-2])  左闭右开，-5开始取，-2无法取到，输出[5,6,7]
print(a[-2:-5])  大于-2，小于-5   无交集，所以输出[]   
像这种负数的取值，就要画数轴
"""
